Research
Security News
Threat Actor Exposes Playbook for Exploiting npm to Build Blockchain-Powered Botnets
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
zen-observable
Advanced tools
The zen-observable npm package provides an implementation of the Observable pattern, which is used for managing asynchronous data streams. It allows you to create, transform, and subscribe to data streams in a declarative manner.
Creating an Observable
This feature allows you to create a new Observable instance. The observer object is used to emit values and signal completion. The subscriber receives these values and handles them accordingly.
const { Observable } = require('zen-observable');
const observable = new Observable(observer => {
observer.next('Hello');
observer.next('World');
observer.complete();
});
observable.subscribe({
next(value) { console.log(value); },
complete() { console.log('Done'); }
});
Transforming Observables
This feature allows you to transform the data emitted by an Observable using operators like map. In this example, each value emitted by the original Observable is multiplied by 2.
const { Observable } = require('zen-observable');
const observable = new Observable(observer => {
observer.next(1);
observer.next(2);
observer.next(3);
observer.complete();
});
const transformed = observable.map(x => x * 2);
transformed.subscribe({
next(value) { console.log(value); },
complete() { console.log('Done'); }
});
Combining Observables
This feature allows you to combine multiple Observables into a single Observable. In this example, two Observables are combined and their values are emitted in sequence.
const { Observable } = require('zen-observable');
const observable1 = new Observable(observer => {
observer.next('A');
observer.complete();
});
const observable2 = new Observable(observer => {
observer.next('B');
observer.complete();
});
const combined = Observable.from([observable1, observable2]).flatMap(x => x);
combined.subscribe({
next(value) { console.log(value); },
complete() { console.log('Done'); }
});
RxJS is a library for reactive programming using Observables, to make it easier to compose asynchronous or callback-based code. It is more feature-rich compared to zen-observable and includes a wide range of operators for transforming, combining, and querying Observables.
Bacon.js is a functional reactive programming library for JavaScript. It provides a comprehensive set of tools for working with event streams and properties. Compared to zen-observable, Bacon.js offers more advanced features for handling complex data flows.
Most.js is a high-performance reactive programming library that focuses on speed and efficiency. It provides a minimalistic API for working with streams. While zen-observable is simpler and easier to use, most.js is optimized for performance and can handle large-scale data streams more efficiently.
An implementation of ES Observables.
Requires ES6 Promises or a Promise polyfill.
npm install zen-observable
Node:
var Observable = require("zen-observable");
Observable.of(1, 2, 3).subscribe(x => console.log(x));
Browser:
<script src="zen-observable.js"></script>
<script>
Observable.of(1, 2, 3).subscribe(x => console.log(x));
</script>
ES Modules:
import Observable from "zen-observable";
Observable.of(1, 2, 3).subscribe(x => console.log(x));
let observable = new Observable(observer => {
// Emit a single value after 1 second
let timer = setTimeout(_=> {
observer.next("hello");
observer.complete();
}, 1000);
// On unsubscription, cancel the timer
return _=> clearTimeout(timer);
});
Creates a new Observable object using the specified subscriber function. The subscriber function is called whenever the subscribe
method of the observable object is invoked. The subscriber function is passed an observer object which has the following methods:
next(value)
Sends the next value in the sequence.error(exception)
Terminates the sequence with an exception.complete()
Terminates the sequence successfully.The subscriber function can optionally return either a cleanup function or a subscription object. If it returns a cleanup function, that function will be called when the subscription has closed. If it returns a subscription object, then the subscription's unsubscribe
method will be invoked when the subscription has closed.
// Logs 1, 2, 3
Observable.of(1, 2, 3).subscribe(x => {
console.log(x);
});
Returns an observable which will emit each supplied argument.
let list = [1, 2, 3];
// Iterate over an object
Observable.from(list).subscribe(x => {
console.log(x);
});
// Convert something "observable" to an Observable instance
Observable.from(otherObservable).subscribe(x => {
console.log(x);
});
Converts value
to an Observable.
value
is an implementation of ES Observables, then it is converted to an instance of Observable as defined by this library.value
.let subscription = observable.subscribe({
next(x) { console.log(x) },
error(err) { console.log(`Finished with error: ${ err }`) },
complete() { console.log("Finished") }
})
Subscribes to the observable. The observer
argument must be an object. It may have any of the following methods:
start(subscription)
Receives the subscription object during initialization.next(value)
Receives the next value of the sequence.error(exception)
Receives the terminating error of the sequence.complete()
Called when the stream has completed successfully.The subscription object can be used to cancel the stream.
// Stop receiving data from the stream
subscription.unsubscribe();
The following methods are not yet defined by the ES Observable specification.
observable.forEach(x => {
console.log(`Received value: ${ x }`);
}).then(_=> {
console.log("Finished successfully")
}).catch(err => {
console.log(`Finished with error: ${ err }`);
})
Subscribes to the observable and returns a Promise for the completion value of the stream. The callback
argument is called once for each value in the stream.
Observable.of(1, 2, 3).filter(value => {
return value > 2;
}).subscribe(value => {
console.log(value);
});
// 3
Returns a new Observable that emits all values which pass the test implemented by the callback
argument.
Returns a new Observable that emits the results of calling the callback
argument for every value in the stream.
Observable.of(1, 2, 3).map(value => {
return value * 2;
}).subscribe(value => {
console.log(value);
});
// 2
// 4
// 6
Observable.of(0, 1, 2, 3, 4).reduce((previousValue, currentValue) => {
return previousValue + currentValue;
}).subscribe(result => {
console.log(result);
});
// 10
Returns a new Observable that applies a function against an accumulator and each value of the stream to reduce it to a single value.
FAQs
An Implementation of ES Observables
The npm package zen-observable receives a total of 2,780,866 weekly downloads. As such, zen-observable popularity was classified as popular.
We found that zen-observable demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.